package com.sicheng.蓝桥.国赛准备.第十三届JavaB;

import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Scanner;

/**
 * @author zsc
 * @version 1.0
 * @date 2022/6/18 20:21
 */
public class H修路 {
    /**
     * 【问题描述】
     * 这天，小明在修路。
     * 他需要修理两条平行的道路 A, B，两条路上面分别有 n 个和 m 个点需要
     * 维修，它们相对于道路起点的距离分别为 a1, a2, . . . , an 和 b1, b2, b, ..., bm。如图，
     * 两条路之间的距离为 d 且它们起点 (最左端) 的连线和两条路都垂直。小明的起
     * 点为道路 A 的起点，他需要尽可能快地遍历这些需要维修的 n + m 个点，他既
     * 可以沿着道路 向右 行走，也可以在两条道路之间的空地上 随意 行走。
     * 小明想知道遍历这些点的最短路程是多少。
     * 【输入格式】
     * 输入共三行，第一行为三个正整数 n, m, d。
     * 第二行为 n 个由空格隔开的正整数 a1, a2, ..., an。
     * 第三行为 m 个由空格隔开的正整数 b1, b2, ..., bm。
     * 试题 H: 修路 15
     * 【输出格式】
     * 一行，一个浮点数，表示答案，保留两位小数。
     * 【样例输入】
     * 2 2 2
     * 2 1
     * 1 2
     * 【样例输出】
     * 5.24
     * 【评测用例规模与约定】
     * 对于 30% 的数据，保证 n + m ≤ 10；
     * 对于 100% 的数据，保证 n, m ≤ 2000, d ≤ 4 × 106, ai, bi ≤ 106 。
     */
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        int d = scanner.nextInt();
        N = m + n + 1;
        // 共m+n+1个点包括(0,0) 建立坐标轴 直线A 是y轴， 垂直与直线A的是x轴 a2(0,1),a1(0,2) b1(d,1) b2(d,2)
        int[][] p = new int[N][2];

        int cnt = 1;

        for (int i = 0; i < m; i++) {
            p[cnt][1] = scanner.nextInt();
            cnt++;
        }

        for (int i = 0; i < n; i++) {
            p[cnt][0] = d;
            p[cnt][1] = scanner.nextInt();
            cnt++;
        }
        g = new double[N][N];
        st = new boolean[N];
        for (double[] ignored : g) {
            Arrays.fill(ignored, Double.MAX_VALUE / 100);
        }
        for (int i = 0; i < p.length - 1; i++) {
            for (int j = i + 1; j < p.length; j++) {
                int x1 = p[i][0];
                int y1 = p[i][1];
                int x2 = p[j][0];
                int y2 = p[j][1];
                if (x1 != x2 || y1 < y2)
                    g[i][j] = dist(x1, y1, x2, y2);
                if (x1 != x2 || y2 < y1)
                    g[j][i] = dist(x1, y1, x2, y2);
            }
        }
        st[0] = true;
        dfs(0, 1, 0);
        System.out.printf("%.2f\n", res);

    }

    static double[][] g;
    static double res = Double.MAX_VALUE;
    static boolean[] st;
    static int N;
    static boolean dfs(int u, int x, double d) {

        if (x == N) {
            res = d;
            return true;
        }
        double min = Double.MAX_VALUE / 100;
        PriorityQueue<P> queue = new PriorityQueue<>(Comparator.comparing(p -> p.d));
        for (int i = 0; i < N; i++) {
            if (!st[i] && i != u && g[u][i] < min) {
                queue.offer(new P(i, g[u][i]));
            }
        }

        boolean dfs;
        while (!queue.isEmpty()) {
            P p = queue.poll();
            st[p.u] = true;
            dfs = dfs(p.u, x + 1, d + p.d);
            if (dfs)
                return true;
            st[p.u] = false;
        }
        return false;
    }

    static class P {
        int u;
        Double d;

        public P(int u, double d) {
            this.u = u;
            this.d = d;
        }
    }

    // a,b 两点之间的距离
    static double dist(int x1, int y1, int x2, int y2) {
        return Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
    }

}
